package com.fanshuai2.niuke.dynamic;
import java.util.*;

/**
 * 王强决定把年终奖用于购物，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：
 * 主件	附件
 * 电脑	打印机，扫描仪
 * 书柜	图书
 * 书桌	台灯，文具
 * 工作椅	无
 * 如果要买归类为附件的物品，必须先买该附件所属的主件，且每件物品只能购买一次。
 *
 * 每个主件可以有 0 个、 1 个或 2 个附件。附件不再有从属于自己的附件。
 * 王强查到了每件物品的价格（都是 10 元的整数倍），而他只有 N 元的预算。除此之外，他给每件物品规定了一个重要度，用整数 1 ~ 5 表示。他希望在花费不超过 N 元的前提下，使自己的满意度达到最大。
 * 满意度是指所购买的每件物品的价格与重要度的乘积的总和
 * 请你帮助王强计算可获得的最大的满意度。
 *
 * 输入描述：
 * 输入的第 1 行，为两个正整数N，m，用一个空格隔开：
 * （其中 N （ N<32000 ）表示总钱数， m （m <60 ）为可购买的物品的个数。）
 * 从第 2 行到第 m+1 行，第 j 行给出了编号为 j-1 的物品的基本数据，每行有 3 个非负整数 v p q
 * （其中 v 表示该物品的价格（ v<10000 ）， p 表示该物品的重要度（ 1 ~ 5 ）， q 表示该物品是主件还是附件。如果 q=0 ，表示该物品为主件，如果 q>0 ，表示该物品为附件， q 是所属主件的编号）
 *
 * 输出描述：
 *  输出一个正整数，为张强可以获得的最大的满意度。
 */
public class Goods {
    static class Good {
        int price;
        int importance;
        int parent;
    }
    static int maxScore(Good[] goods, int M) {
        int n = goods.length;
        int[][] price = new int[n + 1][3];
        int[][] importance = new int[n + 1][3];

        for (int i = 0; i < n; i++) {
            Good good = goods[i];
            if (good.parent == 0) {
                price[i + 1][0] = good.price;
                importance[i + 1][0] = good.importance;
            } else {
                int parent = good.parent;
                if (price[parent][1] == 0) {
                    price[parent][1] = good.price;
                    importance[parent][1] = good.importance;
                }  else {
                    price[parent][2] = good.price;
                    importance[parent][2] = good.importance;
                }
            }
        }
        int[][] dp = new int[n + 1][M + 1];
        for (int i = 1; i <= n; i++) {
            int p0 = price[i][0], v0 = importance[i][0];
            int p1 = price[i][1], v1 = importance[i][1];
            int p2 = price[i][2], v2 = importance[i][2];
            for (int j = 1; j <= M; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j >= p0) {
                    dp[i][j] = Math.max(dp[i - 1][j - p0] + p0 * v0, dp[i][j]);
                }
                if (j >= p0 + p1) {
                    dp[i][j] = Math.max(dp[i - 1][j - p0 - p1] + p0*v0 + p1*v1,
                            dp[i][j]);
                }
                if (j >= p0 + p2) {
                    dp[i][j] = Math.max(dp[i - 1][j - p0 - p2] + p0*v0 + p2*v2,
                            dp[i][j]);
                }
                if (j >= p0 + p1 + p2) {
                    dp[i][j] = Math.max(dp[i - 1][j - p0 - p1 - p2] + p0*v0 + p1*v1 + p2 * v2, dp[i][j]);
                }
            }

        }

        return dp[n][M];
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        while (in.hasNextInt()) {
            int M = in.nextInt();
            int n = in.nextInt();

            Good[] goodArr = new Good[n];
            for (int i = 0; i < n; i++) {
                Good good = new Good();
                good.price = in.nextInt();
                good.importance = in.nextInt();
                good.parent = in.nextInt();
                goodArr[i] = good;
            }
            System.out.println(maxScore(goodArr, M));
        }
    }
}
